const crypto = require("crypto");

/**
 * 获取格式化错误信息
 * @param {Error} err 错误对象
 * @param {{status?: number, message?: string}} defaultConfig 默认配置
 * @returns {Error} 格式化后的错误对象
 */
const getFormatError = (
  err,
  defaultConfig = { status: 400, message: "请求失败" },
) => {
  const error = new Error(
    err?.response?.data?.msg ||
      err?.response?.data?.message ||
      err?.message ||
      defaultConfig?.message ||
      "请求失败",
  );
  error.status =
    err?.response?.status || err?.status || defaultConfig?.status || 400;
  error.data = err?.response?.data || err?.data;
  return error;
};

/**
 * 生成唯一字符串
 * @param {string | number} timestamp 时间戳
 * @returns {string} 唯一字符串
 */
const generateUniqueString = (timestamp) => {
  if (!timestamp) return "";

  // 创建一个 SHA256 哈希
  const hash = crypto.createHash("sha256");
  hash.update(timestamp.toString() + "irelib");

  // 取前 32 位作为最终的字符串（转为十六进制并去除前缀）
  return hash.digest("hex").slice(0, 32);
};

/**
 * 加密函数（AES-256-CBC）
 * @param {string} text 待加密的文本
 * @param {string} key 密钥
 * @returns {object} {data: 加密后的数据, iv 随机向量}
 */
const encryptCBC = (text, key) => {
  // 验证密钥长度
  if (key.length !== 32) throw new Error("密钥长度必须为32位");

  // 使用 AES-256-CBC 加密算法
  const algorithm = "aes-256-cbc";
  // 创建随机初始化向量（IV）
  const iv = crypto.randomBytes(16);
  // 创建加密器
  const cipher = crypto.createCipheriv(algorithm, Buffer.from(key), iv);
  // 加密文本
  let encrypted = cipher.update(text.toString(), "utf8", "hex");
  // 完成加密
  encrypted += cipher.final("hex");
  // 返回加密后的数据和随机向量
  return {
    data: encrypted,
    iv: iv.toString("hex"),
  };
};

/**
 * 解密函数（AES-256-CBC）
 * @param {string} encryptedData 待解密的数据
 * @param {string} key 密钥
 * @param {string} iv 随机向量
 * @returns {string} 解密后的数据
 */
const decryptCBC = (encryptedData, key, iv) => {
  // 验证密钥长度
  if (key.length !== 32) throw new Error("密钥长度必须为32位");

  // 使用 AES-256-CBC 加密算法
  const algorithm = "aes-256-cbc";
  // 创建解密器
  const decipher = crypto.createDecipheriv(
    algorithm,
    Buffer.from(key),
    Buffer.from(iv, "hex"),
  );
  // 解密文本
  let decrypted = decipher.update(encryptedData, "hex", "utf8");
  // 完成解密
  decrypted += decipher.final("utf8");
  // 返回解密后的数据
  return decrypted;
};

/**
 * 加密函数（AES-256-ECB）
 * @param {string} text 待加密的文本
 * @param {string} key 密钥
 * @returns {string} 加密后的数据
 */
const encryptECB = (text, key) => {
  // 验证密钥长度
  if (key.length !== 32) throw new Error("密钥长度必须为32位");

  // 使用 AES-256-ECB 加密算法
  const algorithm = "aes-256-ecb";
  // 创建加密器
  const cipher = crypto.createCipheriv(
    algorithm,
    Buffer.from(key),
    Buffer.alloc(0),
  );
  // 加密文本
  let encrypted = cipher.update(text.toString(), "utf8", "hex");
  // 完成加密
  encrypted += cipher.final("hex");
  return encrypted;
};

/**
 * 解密函数（AES-256-CBC）
 * @param {string} encryptedData 待解密的数据
 * @param {string} key 密钥
 * @returns {string} 解密后的数据
 */
const decryptECB = (encryptedData, key) => {
  // 验证密钥长度
  if (key.length !== 32) throw new Error("密钥长度必须为32位");

  // 使用 AES-256-ECB 加密算法
  const algorithm = "aes-256-ecb";
  // 创建解密器
  const decipher = crypto.createDecipheriv(
    algorithm,
    Buffer.from(key),
    Buffer.alloc(0),
  );
  // 解密数据
  let decrypted = decipher.update(encryptedData, "hex", "utf8");
  // 完成解密
  decrypted += decipher.final("utf8");
  return decrypted;
};

module.exports = {
  generateUniqueString,
  getFormatError,
  encryptCBC,
  decryptCBC,
  encryptECB,
  decryptECB,
};
